package com.chatmcp.mcprouter.jsonrpc;

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * JSON-RPC响应类
 * 表示JSON-RPC 2.0协议中的响应对象
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@JsonInclude(JsonInclude.Include.NON_NULL)
public class JsonRpcResponse {

    /**
     * JSON-RPC协议版本，固定为2.0
     */
    private String jsonrpc = JsonRpcConstants.JSONRPC_VERSION;

    /**
     * 响应结果，成功时存在
     */
    private JsonNode result;

    /**
     * 错误信息，失败时存在
     */
    private JsonRpcError error;

    /**
     * 响应ID，对应请求ID
     */
    private Object id;

    /**
     * 将结果反序列化为指定类型的对象
     *
     * @param valueType 目标类型
     * @param <T> 返回类型
     * @return 反序列化的对象
     * @throws JsonProcessingException 如果反序列化失败
     */
    public <T> T unmarshalResult(Class<T> valueType) throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        return mapper.treeToValue(result, valueType);
    }

    /**
     * 将响应转换为字符串
     *
     * @return 响应的字符串表示
     */
    public String toString() {
        try {
            ObjectMapper mapper = new ObjectMapper();
            return mapper.writeValueAsString(this);
        } catch (JsonProcessingException e) {
            return "{\"jsonrpc\":\"2.0\",\"error\":{\"code\":-32603,\"message\":\"Failed to serialize response\"},\"id\":null}";
        }
    }

    /**
     * 创建一个成功响应
     *
     * @param result 响应结果
     * @param id     响应ID
     * @return 成功响应对象
     */
    public static JsonRpcResponse success(JsonNode result, Object id) {
        return JsonRpcResponse.builder()
                .jsonrpc(JsonRpcConstants.JSONRPC_VERSION)
                .id(id)
                .result(result)
                .build();
    }

    /**
     * 创建一个错误响应
     *
     * @param error 错误信息
     * @param id    响应ID
     * @return 错误响应对象
     */
    public static JsonRpcResponse error(Object id, JsonRpcError error) {
        return JsonRpcResponse.builder()
                .jsonrpc(JsonRpcConstants.JSONRPC_VERSION)
                .id(id)
                .error(error)
                .build();
    }

    /**
     * 创建一个解析错误响应
     *
     * @param id 响应ID
     * @return 解析错误响应对象
     */
    public static JsonRpcResponse parseError(Object id) {
        return error(id, JsonRpcError.parseError());
    }

    /**
     * 创建一个无效请求错误响应
     *
     * @param message 错误消息
     * @return 无效请求错误响应对象
     */
    public static JsonRpcResponse invalidRequest(String message) {
        return error(null, JsonRpcError.invalidRequest(message));
    }

    /**
     * 创建一个方法不存在错误响应
     *
     * @param id      请求ID
     * @param method  方法名
     * @return 方法不存在错误响应对象
     */
    public static JsonRpcResponse methodNotFound(Object id, String method) {
        return error(id, JsonRpcError.methodNotFound(method));
    }

    /**
     * 创建一个无效参数错误响应
     *
     * @param id      请求ID
     * @param message 错误消息
     * @return 无效参数错误响应对象
     */
    public static JsonRpcResponse invalidParams(Object id, String message) {
        return error(id, JsonRpcError.invalidParams(message));
    }

    /**
     * 创建一个内部错误响应
     *
     * @param id 响应ID
     * @return 内部错误响应对象
     */
    public static JsonRpcResponse internalError(Object id) {
        return error(id, JsonRpcError.internalError());
    }

    /**
     * 创建一个内部错误响应（带消息）
     *
     * @param id      请求ID
     * @param message 错误消息
     * @return JSON-RPC响应
     */
    public static JsonRpcResponse internalError(Object id, String message) {
        return error(id, JsonRpcError.internalError(message));
    }

    /**
     * 创建一个代理错误响应
     *
     * @param id 响应ID
     * @return 代理错误响应对象
     */
    public static JsonRpcResponse proxyError(Object id) {
        return error(id, JsonRpcError.proxyError());
    }

    /**
     * 创建一个代理错误响应
     *
     * @param id      请求ID
     * @param message 错误消息
     * @return JSON-RPC响应
     */
    public static JsonRpcResponse proxyError(Object id, String message) {
        return error(id, JsonRpcError.proxyError(message));
    }
    
    /**
     * 将JSON字符串反序列化为响应对象
     *
     * @param data JSON字符串
     * @return 响应对象
     * @throws JsonProcessingException 如果反序列化失败
     */
    public static JsonRpcResponse unmarshalResponse(String data) throws JsonProcessingException {
        ObjectMapper mapper = new ObjectMapper();
        return mapper.readValue(data, JsonRpcResponse.class);
    }
} 